package net.suncaper.mvc.service.impl;

import net.suncaper.mvc.exception.BusinessException;
import net.suncaper.mvc.mapper.UserMapper;
import net.suncaper.mvc.mapper.impl.UserMapperImpl;
import net.suncaper.mvc.model.domain.User;
import net.suncaper.mvc.service.IUserService;

import java.util.List;
import java.util.UUID;
import java.util.Date;

/**
 * 用户业务接口实现类
 */
public class UserServiceImpl implements IUserService {
    private final UserMapper userMapper = new UserMapperImpl();

    /**
     * 用户注册
     *
     * @param email 邮箱
     * @param password 密码
     * @param avatar 头像URL
     * @param gender 性别
     * @param age 年龄
     * @param roleId 角色ID (只能是普通用户或酒店商家)
     * @param hotelName 酒店名称 (仅酒店商家需要)
     * @return 注册成功的用户信息
     */
    public User register(String email, String password, String avatar, Integer gender, Integer age, Integer roleId, String hotelName) {
        // 校验必填字段
        if (email == null || password == null) {
            throw new BusinessException("邮箱和密码不能为空");
        }
        
        // 邮箱格式校验
        if (!email.matches("^[a-zA-Z0-9_-]+@[a-zA-Z0-9_-]+(\\.[a-zA-Z0-9_-]+)+$")) {
            throw new BusinessException("邮箱格式不正确");
        }
        
        // 密码长度校验
        if (password.length() < 6) {
            throw new BusinessException("密码长度不能少于6位");
        }
        
        // 判断邮箱是否已存在
        boolean emailExists = userMapper.isEmailExists(email);
        if (emailExists) {
            throw new BusinessException("该邮箱已被注册");
        }
        
        // 角色ID校验 - 只能是普通用户(1)或酒店商家(2)
        if (roleId == null) {
            // 默认为普通用户
            roleId = 1;
        } else if (roleId != 1 && roleId != 2) {
            throw new BusinessException("无效的角色选择");
        }
        
        // 如果是酒店商家，则必须提供酒店名称
        if (roleId == 2 && (hotelName == null || hotelName.trim().isEmpty())) {
            throw new BusinessException("酒店商家必须提供酒店名称");
        }
        
        // 创建用户对象
        User user = new User();
        // 使用UUID生成用户ID
        user.setUserId(UUID.randomUUID().toString().replace("-", ""));
        user.setEmail(email);
        user.setPassword(password);
        user.setAvatar(avatar);
        // 默认设置用户状态为正常(1)
        user.setStatus(1);
        user.setGender(gender);
        user.setAge(age);
        user.setCreateTime(new Date());
        
        // 保存用户信息
        boolean result = userMapper.insertUser(user);
        if (!result) {
            throw new BusinessException("注册失败，请稍后重试");
        }
        
        // 创建用户角色关联
        userMapper.insertUserRole(user.getUserId(), roleId, roleId == 2 ? hotelName : null);
        
        return user;
    }

    /**
     * 新增用户信息和用户角色关联
     *
     * @param user 用户信息
     * @param roleId 角色ID
     * @param hotelName 酒店名称（仅当角色为酒店商家时使用）
     * @return 新增结果
     */
    @Override
    public boolean createUserWithRole(User user, Integer roleId, String hotelName) {
        // 校验必填字段
        if (user.getUserId() == null || user.getEmail() == null || user.getPassword() == null) {
            throw new BusinessException("用户信息不完整，请补充必要信息");
        }

        // 判断邮箱是否已存在
        boolean emailExists = userMapper.isEmailExists(user.getEmail());
        if (emailExists) {
            throw new BusinessException("用户邮箱已经存在，请使用其他邮箱注册");
        }
        
        // 如果没有设置状态，默认为正常状态
        if (user.getStatus() == null) {
            user.setStatus(1);
        }
        
        // 如果没有设置创建时间，设置为当前时间
        if (user.getCreateTime() == null) {
            user.setCreateTime(new Date());
        }

        // 开始事务
        try {
            // 1. 插入用户信息
            boolean userResult = userMapper.insertUser(user);
            if (!userResult) {
                throw new BusinessException("创建用户失败");
            }

            // 2. 如果有角色ID，则建立用户角色关联
            if (roleId != null) {
                boolean roleResult = userMapper.insertUserRole(user.getUserId(), roleId, hotelName);
                if (!roleResult) {
                    throw new BusinessException("创建用户角色关联失败");
                }
            }

            return true;
        } catch (Exception e) {
            // 出现异常，记录日志
            System.out.println("[UserServiceImpl.createUserWithRole] 创建用户失败: " + e.getMessage());
            // 抛出业务异常
            throw new BusinessException("创建用户失败: " + e.getMessage());
        }
    }

    /**
     * 新增用户信息
     *
     * @param user 用户信息
     * @return 新增结果
     */
    @Override
    public boolean createUser(User user) {
        return createUserWithRole(user, null, null);
    }

    /**
     * 根据用户ID查询用户信息
     *
     * @param userId 用户ID
     * @return 用户信息
     */
    @Override
    public User getUserById(String userId) {
        return userMapper.selectUserById(userId);
    }

    /**
     * 根据邮箱查询用户信息
     *
     * @param email 邮箱
     * @return 用户信息
     */
    @Override
    public User getUserByEmail(String email) {
        return userMapper.selectUserByEmail(email);
    }

    /**
     * 查询所有用户信息
     *
     * @return 用户列表
     */
    @Override
    public List<User> getAllUsers() {
        return userMapper.selectAllUsers();
    }

    /**
     * 更新用户基本信息和角色关联
     * 
     * @param user 用户信息
     * @param roleId 角色ID
     * @param hotelName 酒店名称
     * @return 更新结果
     */
    public boolean updateUserWithRole(User user, Integer roleId, String hotelName) {
        // 校验用户是否存在
        User existingUser = userMapper.selectUserById(user.getUserId());
        if (existingUser == null) {
            throw new BusinessException("要更新的用户不存在");
        }

        // 如果更新了邮箱，检查新邮箱是否已被使用
        if (!user.getEmail().equals(existingUser.getEmail())) {
            boolean emailExists = userMapper.isEmailExists(user.getEmail());
            if (emailExists) {
                throw new BusinessException("新邮箱已被其他用户使用");
            }
        }

        try {
            // 1. 更新用户基本信息
            boolean userResult = userMapper.updateUser(user);
            if (!userResult) {
                throw new BusinessException("更新用户信息失败");
            }

            // 2. 更新用户角色关联
            // 如果提供了角色ID
            if (roleId != null) {
                // 先检查是否已存在角色关联
                boolean hasRole = userMapper.isUserRoleExists(user.getUserId());
                
                // 如果已存在，先删除旧的关联
                if (hasRole) {
                    userMapper.deleteUserRoleByUserId(user.getUserId());
                }
                
                // 创建新的角色关联
                boolean roleResult = userMapper.insertUserRole(user.getUserId(), roleId, hotelName);
                if (!roleResult) {
                    throw new BusinessException("更新用户角色关联失败");
                }
            }

            return true;
        } catch (Exception e) {
            System.out.println("[UserServiceImpl.updateUserWithRole] 更新用户失败: " + e.getMessage());
            throw new BusinessException("更新用户失败: " + e.getMessage());
        }
    }

    /**
     * 更新用户个人信息
     *
     * @param userId 当前用户ID
     * @param newUserId 新的用户ID（可选，为null时不修改）
     * @param avatar 头像URL
     * @param gender 性别
     * @param age 年龄
     * @return 更新后的用户信息
     */
    @Override
    public User updateUserProfile(String userId, String newUserId, String avatar, Integer gender, Integer age) {
        // 获取当前用户信息
        User user = userMapper.selectUserById(userId);
        if (user == null) {
            throw new BusinessException("用户不存在");
        }

        // 如果要修改用户ID，需要检查新ID是否与其他用户冲突
        if (newUserId != null && !newUserId.isEmpty() && !newUserId.equals(userId)) {
            // 检查新用户ID是否已存在
            User existingUser = userMapper.selectUserById(newUserId);
            if (existingUser != null) {
                throw new BusinessException("用户ID已被使用，请选择其他ID");
            }
            
            // 设置新的用户ID
            String oldUserId = user.getUserId();
            user.setUserId(newUserId);
            
            // 更新用户信息
            user.setAvatar(avatar);
            user.setGender(gender);
            user.setAge(age);
            
            // 先插入新记录
            boolean insertResult = userMapper.insertUser(user);
            if (!insertResult) {
                throw new BusinessException("更新用户信息失败");
            }
            
            // 复制用户角色关联
            Integer roleId = userMapper.selectRoleIdByUserId(oldUserId);
            String hotelName = userMapper.selectHotelNameByUserId(oldUserId);
            if (roleId != null) {
                userMapper.insertUserRole(newUserId, roleId, hotelName);
            }
            
            // 删除旧记录
            userMapper.deleteUser(oldUserId);
            
            // 返回更新后的用户信息
            return userMapper.selectUserById(newUserId);
        } else {
            // 只更新其他信息，不修改用户ID
            user.setAvatar(avatar);
            user.setGender(gender);
            user.setAge(age);
            
            // 执行更新
            boolean result = userMapper.updateUser(user);
            if (!result) {
                throw new BusinessException("更新用户信息失败");
            }
            
            // 返回更新后的用户信息
            return userMapper.selectUserById(userId);
        }
    }

    /**
     * 更新用户信息
     *
     * @param user 用户信息
     * @return 更新结果
     */
    @Override
    public boolean updateUser(User user) {
        // 校验用户是否存在
        User existingUser = userMapper.selectUserById(user.getUserId());
        if (existingUser == null) {
            throw new BusinessException("要更新的用户不存在");
        }

        // 如果更新了邮箱，检查新邮箱是否已被使用
        if (!user.getEmail().equals(existingUser.getEmail())) {
            boolean emailExists = userMapper.isEmailExists(user.getEmail());
            if (emailExists) {
                throw new BusinessException("新邮箱已被其他用户使用");
            }
        }

        return userMapper.updateUser(user);
    }

    /**
     * 删除用户信息
     *
     * @param userId 用户ID
     * @return 删除结果
     */
    @Override
    public boolean deleteUser(String userId) {
        // 校验用户是否存在
        User existingUser = userMapper.selectUserById(userId);
        if (existingUser == null) {
            throw new BusinessException("要删除的用户不存在");
        }

        // 检查用户是否有未完成的订单或评价等关联数据
        // 此处省略具体实现，实际项目中需要处理关联数据

        // 先删除用户角色关联
        userMapper.deleteUserRoleByUserId(userId);

        // 再删除用户
        return userMapper.deleteUser(userId);
    }

    /**
     * 用户登录验证
     *
     * @param email    邮箱
     * @param password 密码
     * @return 用户信息
     */
    @Override
    public User login(String email, String password) {
        User user = userMapper.selectUserByEmail(email);
        if (user == null) {
            System.out.println("[UserServiceImpl.login] 登录失败，用户不存在，email=" + email + ", password=" + password);
            throw new BusinessException("用户不存在");
        }
        if (!user.getPassword().equals(password)) {
            System.out.println("[UserServiceImpl.login] 登录失败，密码错误，userId=" + user.getUserId() + ", email=" + email + ", password=" + password);
            throw new BusinessException("密码错误");
        }
        System.out.println("[UserServiceImpl.login] 登录成功，userId=" + user.getUserId() + ", email=" + email + ", password=" + password);
        return user;
    }

    /**
     * 获取用户角色ID
     *
     * @param userId 用户ID
     * @return 角色ID
     */
    @Override
    public Integer getUserRoleId(String userId) {
        return userMapper.selectRoleIdByUserId(userId);
    }

    /**
     * 获取酒店商家关联的酒店名称
     *
     * @param userId 用户ID
     * @return 酒店名称
     */
    @Override
    public String getHotelName(String userId) {
        return userMapper.selectHotelNameByUserId(userId);
    }
} 